Over the last ten years, computers and computing technology have grown tremendously due, in no small part, to the growth and reach of the Internet. Computer applications, once delivered on a disk in some kind of marketing package, are now available and even operable over the Internet. These Internet applications allow consumers to take advantage of the logic behind the application without buying the software for installation on a local computer. The prevalence of Internet connections has also allowed developers to create automatic updating features for computer applications. As such applications are started up, an update feature will typically establish a connection with a remote server over the Internet to search for any updates to the code or features of the application and download those to the application. The user may then execute the update file and restart the application once the update file has finished updating the application. Application development, as a consequence, now encompasses not only building or coding stand-alone software applications that users can buy on disk or download from a remote server, but also developing Internet-active applications that can either run on a client machine and check for updates and/or other information via the Internet or run on a remote server, while serving their logic to client users over the Internet. Application development environments have also evolved correspondingly to account for the development process including such interactions with remote servers.
Programming techniques have also evolved during the growth of computing technology. Modular programming techniques, such as Object Oriented Programming (OOP), have been developed that encourages reuse and/or interchange of pieces of software between or within programs. Self-sufficient modules may be created that contain the data and processing and then formed as objects within the program. Thus, a developer would spend the time to develop the module or class once and then be able to use it in various instances throughout one or a number of programs. One such modular concept is the use of components for developing interactive applications.
Components are modular pieces of software that have a variable set of parameters that allows a developer to change the appearance and/or function of the component object at runtime. Application development environments such as MACROMEDIA INC.'s MACROMEDIA FLASHMX™, MACROMEDIA INC.'s DREAMWEAVER™, and the like, include various pre-built components that developers may use in building various applications. The components generally include parameters that the developer may set in order to customize the application of the component as desired by the developer. By using components, developers may save considerable time creating complex applications. Components include items such as interface controls, including radio buttons, check boxes, input fields, scroll bars, and the like; data components, which allow loading and manipulating information from data sources; media components, that allow playback and control of streaming media; manager components, that allow managing non-visual components such as focus or depth, popups, styles, and the like; as well as various other program elements.
Application development environments that utilize components typically provide various interface elements to the developer in order to assist him or her in deploying components more easily. Insert bars, code hinting, and tag or component inspectors are each examples of different interface elements that some application development environments may provide to facilitate the use of components. An insert bar is typically a toolbar that displays icons or buttons corresponding to the available components. When the developer selects the icon that corresponds to the desired component, the application development environment creates an instance of the component and places it in the editing region.
Application development environments typically employ one or both of a code view edit mode, in which the actual code or script is presented to the user for text-editing, a design view mode, in which the code of the underlying application is rendered to the developer as it would be rendered in operation (e.g., a Hypertext Markup Language (HTML) page being rendered in a Web browser). In the design view mode, the developers generally graphically manipulate the application as rendered on the display. When the application development environment inserts the component selected, it will place the component in which ever edit mode the developer is using. The developer would then be able to manipulate the position and parameters of the component to fit it within the application being developed. Therefore, in order to properly display the component on the design view canvas, the application development environment typically has access to the visual representation of the component. In existing application development environments, only the visual representation of standard or built-in components are available. Any components that are design by the user or other individual developers will not be available for visual rendering in the design view surface or canvas of the application development environment. Thus, existing application development environments typically cannot display user-created components on the design view surface or canvas.
Code hinting is a help feature that is used by many application development environments in a code view editing mode. As the user types code, a popup box appears near the insertion point that lists possible code, components, or application programming interface (API) methods or commands associated with the input typed by the developer. The developer may then scroll through the list and pick the specific component, tag, method, or the like from the displayed list instead of typing the desired information to completion. Again, as the developer makes the particular selection, the application development environment inserts the code and/or visual rendering of the component or object in the edit region.
Tag or component inspectors are a version of a property inspector that is directed specifically to programming tags or commands rather than the properties of an object. A tag or component inspector is typically a visual interface element that presents the available information on a highlighted tag or piece of code. It generally lists the properties, settings, elements, and the like of the highlighted code and also usually provides an edit interface that allows the developer to edit the code from within the tag inspector rather than in the code view or design view of the editing region. For example, a developer may highlight a button component tag, which causes the properties of the button component to appear on the tag inspector. If the developer desired to modify the shape or color of the button component, he or she could manipulate the color and/or shape properties directly in the tag inspector interface. As the user updates the properties in the tag inspector, the editing region updates to reflect either the updated code or re-renders to the updated visual representation of the component.
Many application development environments also allow users and developers to create their own components. The developers may save these customized components along with the pre-existing components for use in future projects. However, application development environments generally cannot include the user-defined custom components in the various component interfaces, such as the insert bar, code hinting, and tag inspectors. Moreover, the user-defined custom components cannot be displayed on the design view canvas or surface. These component interfaces and the design view canvas are typically limited to the objects that are defined by the manufacturer before each version of the software ships. Therefore, developers would have little opportunity to modify the source or object code of the application development environment. Moreover, once the application has been manufactured and shipped, new components developed by third parties or the manufacturer itself typically may not be updated into the component interface until any subsequent software version release.